The comment "Root in vid-space is 0 → physical core 0" is incorrect. Based on the vid mapping (vid = num_cores - 1 - core_id) and root_vid = num_cores - 1, the root has vid = num_cores - 1, not vid = 0. For example, with 8 cores: core 0 has vid=7 (root), core 7 has vid=0 (leaf). The comment should say "Root in vid-space is (num_cores-1) → physical core 0".

The ASSERT checking num_heads_per_core == 1 when actual_num_children > 0 may be too restrictive. This assertion fails if a core processes multiple heads and any of those heads require tree reduction. However, the tree reduction logic operates per-head (inside the cur_head loop starting at line 236), so it should support multiple heads per core. Consider removing this assertion or moving it outside the head loop if the intent is to ensure heads aren't split across cores within a single reduction group.

The cb_pop_front for cb_index_id is commented out (line 149), which may cause the circular buffer to fill up if multiple operations try to use it. The comment references issue #27979, suggesting this is a known workaround for a mailbox-based synchronization issue. However, if this buffer is meant to be reused across multiple calls or heads, not popping it will eventually exhaust the buffer. Consider documenting why this pop is commented out and whether it needs to be addressed when the referenced issue is resolved.

Early return at line 336 skips processing of remaining heads when num_heads_per_core > 1. The return statement is inside the head loop (lines 236-238), so sending to parent causes the kernel to exit completely rather than continuing to the next head. This breaks multi-head processing. The return should be replaced with a break or continue, or the send logic should be moved outside the head loop if each core only processes one head during tree reduction (which the ASSERT at line 245 suggests).

The semaphore is polled but never reset within or after the tree reduction rounds. If num_heads_per_core > 1, the outer loop iterates multiple times (lines 236-238), and the semaphore state from the first head will cause the second head to incorrectly think data has arrived. The semaphore needs to be reset after processing all children, or the encoding scheme needs to account for multiple heads per core.

Missing CB pop operations after consuming child data. The code reads from cb_l_in (line 537) and cb_out_o (line 559) but only pops cb_m_in (line 573). The cb_l_in and cb_out_o circular buffers need cb_pop_front calls to free the consumed tiles, otherwise the CBs will fill up and block on subsequent rounds or heads. Add: cb_pop_front(cb_l_in, Sq_chunk_t) and cb_pop_front(cb_out_o, out_chunk_tiles) after line 575.

Missing cb_pop_front for sum buffer in root finalization. At line 660, only cb_prev_max is popped, but cb_prev_sum is also consumed (used in lines 607, 614, 622, 628) and needs to be freed. When actual_num_children == 0, cb_cur_sum is used instead but also not popped. Add cb_pop_front(sum_cb, Sq_chunk_t) after line 660 to properly release the consumed sum buffer.

The writer runtime args size for idle cores doesn't account for reducer and output core coordinates. The active cores receive additional args via insert operations at lines 1180-1183, appending reduce_core_physical_xs, reduce_core_physical_ys, output_core_physical_xs, and output_core_physical_ys. However, the idle core size calculation at line 1221 only accounts for base args, children_per_round, and group coords. The size should be: 16 + MAX_TREE_REDUCTION_ROUNDS + 2num_cores_per_head + 2num_reducer_cores + 2*num_output_cores.

The semaphore encoding uses 4-bit nibbles per round (lines 65-70), which limits each round's counter to 0-15. This means a parent can receive from at most 15 children per round. With the binary tree structure, each parent receives from at most 1 child per round, so this is sufficient. However, if the tree structure changes in the future to allow multiple children per round, this encoding would fail. Consider adding a compile-time assertion or comment explaining this constraint.

No runtime validation that num_tree_reduction_rounds doesn't exceed MAX_TREE_REDUCTION_ROUNDS. If num_cores_per_head is greater than 2^MAX_TREE_REDUCTION_ROUNDS (64), the system would silently produce incorrect results or access out-of-bounds array indices. Add a runtime check: TT_FATAL(num_tree_reduction_rounds <= MAX_TREE_REDUCTION_ROUNDS, "Tree reduction rounds {} exceeds maximum {}", num_tree_reduction_rounds, MAX_TREE_REDUCTION_ROUNDS).

⚠️ cppcoreguidelines-pro-type-member-init ⚠️
uninitialized record type: params

⚠️ modernize-loop-convert ⚠️
use range-based for loop instead

⚠️ modernize-loop-convert ⚠️
use range-based for loop instead

⚠️ modernize-loop-convert ⚠️
use range-based for loop instead

⚠️ readability-math-missing-parentheses ⚠️
* has higher precedence than +; add parentheses to explicitly specify the order of operations

why does data arrive in order m, l, o, if l is processed first?

the send order got messed up, should be arriving in order of l, m, o just fixed, will do a few more passes of the code to double check